/*-------------------------------------------------------------------------
 *
 * syscache.h
 *      System catalog cache definitions.
 *
 * See also lsyscache.h, which provides convenience routines for
 * common cache-lookup operations.
 *
 * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 * Portions Copyright (c) 2010-2012 Postgres-XC Development Group
 *
 * This source code file contains modifications made by THL A29 Limited ("Tencent Modifications").
 * All Tencent Modifications are Copyright (C) 2023 THL A29 Limited.
 *
 * src/include/utils/syscache.h
 *
 *-------------------------------------------------------------------------
 */
#ifndef SYSCACHE_H
#define SYSCACHE_H

#include "access/attnum.h"
#include "access/htup.h"
/* we intentionally do not include utils/catcache.h here */

/*
 *        SysCache identifiers.
 *
 *        The order of these identifiers must match the order
 *        of the entries in the array cacheinfo[] in syscache.c.
 *        Keep them in alphabetical order (renumbering only costs a
 *        backend rebuild).
 */

enum SysCacheIdentifier
{
    AGGFNOID = 0,
    AMNAME,
    AMOID,
    AMOPOPID,
    AMOPSTRATEGY,
    AMPROCNUM,
    ATTNAME,
    ATTNUM,
#ifdef __AUDIT__
    AUDITSTMTCONF,
    AUDITSTMTCONFOID,
    AUDITUSERCONF,
    AUDITUSERCONFOID,
    AUDITOBJCONF,
    AUDITOBJCONFOID,
    AUDITOBJDEFAULT,
    AUDITOBJDEFAULTOID,
    AUDITFGAPOLICYCONF,
    AUDITFGAOBJPOLICYCONF,
#endif
    AUTHMEMMEMROLE,
    AUTHMEMROLEMEM,
    AUTHNAME,
    AUTHOID,
    CASTSOURCETARGET,
    CLAAMNAMENSP,
    CLAOID,
#ifdef _MLS_    
    CLSCOMOID,
    CLSGRPOID,
    CLSLABELOID,
    CLSLEVELOID,
    CLSPOLOID,
    CLSTBLOID,
    CLSUSEROID,
#endif    
    COLLNAMEENCNSP,
    COLLOID,
    CONDEFAULT,
    CONNAMENSP,
    CONSTROID,
    CONVOID,
    DATABASEOID,
#ifdef _MLS_    
    DATAMASKOID,
    DATAMASKUSEROID,
#endif    
    DEFACLROLENSPOBJ,
    ENUMOID,
    ENUMTYPOIDNAME,
    EVENTTRIGGERNAME,
    EVENTTRIGGEROID,
    FOREIGNDATAWRAPPERNAME,
    FOREIGNDATAWRAPPEROID,
    FOREIGNSERVERNAME,
    FOREIGNSERVEROID,
    FOREIGNTABLEREL,
    INDEXRELID,
    LANGNAME,
    LANGOID,
    NAMESPACENAME,
    NAMESPACEOID,
    OPERNAMENSP,
    OPEROID,
    OPFAMILYAMNAMENSP,
    OPFAMILYOID,
#ifdef PGXC
    PGXCCLASSRELID,
    PGXCGROUPNAME,
    PGXCGROUPOID,
    PGXCNODENAME,
    PGXCNODEOID,
    PGXCNODEIDENTIFIER,
#endif
#ifdef __OPENTENBASE__
    PGPARTITIONINTERVALREL,
#endif
    PARTRELID,
    PROCNAMEARGSNSP,
    PROCOID,
    PUBLICATIONNAME,
    PUBLICATIONOID,
    PUBLICATIONREL,
    PUBLICATIONRELMAP,
#ifdef __STORAGE_SCALABLE__
    PUBLICATIONSHARD,
    PUBLICATIONSHARDMAP,
#endif
    RANGETYPE,
    RELNAMENSP,
    RELOID,
    REPLORIGIDENT,
    REPLORIGNAME,
    RULERELNAME,
    SEQRELID,
#ifdef __COLD_HOT__
    SHARDKEYVALUE,
#endif
    STATEXTNAMENSP,
    STATEXTOID,
    STATRELATTINH,
    SUBSCRIPTIONNAME,
    SUBSCRIPTIONOID,
    SUBSCRIPTIONRELMAP,
#ifdef __STORAGE_SCALABLE__
    SUBSCRIPTIONSHARD,
    SUBSCRIPTIONSHARDMAP,
    SUBSCRIPTIONSHARDPUBNAME,
    SUBSCRIPTIONTABLE,
    SUBSCRIPTIONTABLEMAP,
    SUBSCRIPTIONTABLEOID,
#endif
    TABLESPACEOID,
#ifdef _MLS_    
    TCPALGORITHM,
    TCPOID,
    TCPSOID,
    TCPTOID,
#endif    
    TRFOID,
    TRFTYPELANG,
    TSCONFIGMAP,
    TSCONFIGNAMENSP,
    TSCONFIGOID,
    TSDICTNAMENSP,
    TSDICTOID,
    TSPARSERNAMENSP,
    TSPARSEROID,
    TSTEMPLATENAMENSP,
    TSTEMPLATEOID,
    TYPENAMENSP,
    TYPEOID,
    USERMAPPINGOID,
    USERMAPPINGUSERSERVER

#define SysCacheSize (USERMAPPINGUSERSERVER + 1)
};

extern void InitCatalogCache(void);
extern void InitCatalogCachePhase2(void);

extern HeapTuple SearchSysCache(int cacheId,
               Datum key1, Datum key2, Datum key3, Datum key4);
extern void ReleaseSysCache(HeapTuple tuple);

/* convenience routines */
extern HeapTuple SearchSysCacheCopy(int cacheId,
                   Datum key1, Datum key2, Datum key3, Datum key4);
extern bool SearchSysCacheExists(int cacheId,
                     Datum key1, Datum key2, Datum key3, Datum key4);
extern Oid GetSysCacheOid(int cacheId,
               Datum key1, Datum key2, Datum key3, Datum key4);

extern HeapTuple SearchSysCacheAttName(Oid relid, const char *attname);
extern HeapTuple SearchSysCacheCopyAttName(Oid relid, const char *attname);
extern bool SearchSysCacheExistsAttName(Oid relid, const char *attname);

extern Datum SysCacheGetAttr(int cacheId, HeapTuple tup,
                AttrNumber attributeNumber, bool *isNull);

extern uint32 GetSysCacheHashValue(int cacheId,
                     Datum key1, Datum key2, Datum key3, Datum key4);

/* list-search interface.  Users of this must import catcache.h too */
struct catclist;
extern struct catclist *SearchSysCacheList(int cacheId, int nkeys,
                   Datum key1, Datum key2, Datum key3, Datum key4);

extern void SysCacheInvalidate(int cacheId, uint32 hashValue);

extern bool RelationInvalidatesSnapshotsOnly(Oid relid);
extern bool RelationHasSysCache(Oid relid);
extern bool RelationSupportsSysCache(Oid relid);

#ifdef __AUDIT__
extern void GetSysCacheInfo(int32 cacheid,
                            Oid * reloid,
                            Oid * indoid,
                            int * nkeys);
#endif

/*
 * The use of the macros below rather than direct calls to the corresponding
 * functions is encouraged, as it insulates the caller from changes in the
 * maximum number of keys.
 */
#define SearchSysCache1(cacheId, key1) \
    SearchSysCache(cacheId, key1, 0, 0, 0)
#define SearchSysCache2(cacheId, key1, key2) \
    SearchSysCache(cacheId, key1, key2, 0, 0)
#define SearchSysCache3(cacheId, key1, key2, key3) \
    SearchSysCache(cacheId, key1, key2, key3, 0)
#define SearchSysCache4(cacheId, key1, key2, key3, key4) \
    SearchSysCache(cacheId, key1, key2, key3, key4)

#define SearchSysCacheCopy1(cacheId, key1) \
    SearchSysCacheCopy(cacheId, key1, 0, 0, 0)
#define SearchSysCacheCopy2(cacheId, key1, key2) \
    SearchSysCacheCopy(cacheId, key1, key2, 0, 0)
#define SearchSysCacheCopy3(cacheId, key1, key2, key3) \
    SearchSysCacheCopy(cacheId, key1, key2, key3, 0)
#define SearchSysCacheCopy4(cacheId, key1, key2, key3, key4) \
    SearchSysCacheCopy(cacheId, key1, key2, key3, key4)

#define SearchSysCacheExists1(cacheId, key1) \
    SearchSysCacheExists(cacheId, key1, 0, 0, 0)
#define SearchSysCacheExists2(cacheId, key1, key2) \
    SearchSysCacheExists(cacheId, key1, key2, 0, 0)
#define SearchSysCacheExists3(cacheId, key1, key2, key3) \
    SearchSysCacheExists(cacheId, key1, key2, key3, 0)
#define SearchSysCacheExists4(cacheId, key1, key2, key3, key4) \
    SearchSysCacheExists(cacheId, key1, key2, key3, key4)

#define GetSysCacheOid1(cacheId, key1) \
    GetSysCacheOid(cacheId, key1, 0, 0, 0)
#define GetSysCacheOid2(cacheId, key1, key2) \
    GetSysCacheOid(cacheId, key1, key2, 0, 0)
#define GetSysCacheOid3(cacheId, key1, key2, key3) \
    GetSysCacheOid(cacheId, key1, key2, key3, 0)
#define GetSysCacheOid4(cacheId, key1, key2, key3, key4) \
    GetSysCacheOid(cacheId, key1, key2, key3, key4)

#define GetSysCacheHashValue1(cacheId, key1) \
    GetSysCacheHashValue(cacheId, key1, 0, 0, 0)
#define GetSysCacheHashValue2(cacheId, key1, key2) \
    GetSysCacheHashValue(cacheId, key1, key2, 0, 0)
#define GetSysCacheHashValue3(cacheId, key1, key2, key3) \
    GetSysCacheHashValue(cacheId, key1, key2, key3, 0)
#define GetSysCacheHashValue4(cacheId, key1, key2, key3, key4) \
    GetSysCacheHashValue(cacheId, key1, key2, key3, key4)

#define SearchSysCacheList1(cacheId, key1) \
    SearchSysCacheList(cacheId, 1, key1, 0, 0, 0)
#define SearchSysCacheList2(cacheId, key1, key2) \
    SearchSysCacheList(cacheId, 2, key1, key2, 0, 0)
#define SearchSysCacheList3(cacheId, key1, key2, key3) \
    SearchSysCacheList(cacheId, 3, key1, key2, key3, 0)
#define SearchSysCacheList4(cacheId, key1, key2, key3, key4) \
    SearchSysCacheList(cacheId, 4, key1, key2, key3, key4)

#define ReleaseSysCacheList(x)    ReleaseCatCacheList(x)

#endif                            /* SYSCACHE_H */
